# -*- coding: utf-8 -*-
#   文件说明
# @Time    ： 2025/9/2  03:02
# @Auther  ： 徐良
# File     :  aloneBillBase.py
from typing import List, Any, Dict, Optional, Union
from PySide6.QtWidgets import QWidget
from dbService import get_model
from baseClass.model.editableQueryModel import EditableSqlModel
from businessLogic.globalDict.global_domain import domain_dict
from baseClass.tools.tableToList import TableToListDict


class AloneBillBase(QWidget):
    """
    单据处理基类，支持form表体数据管理
    分离构造与配置
    """

    def __init__(self, parent: Optional[QWidget] = None):
        super().__init__(parent)

        self.WORK_CLASS_NAME = '独立表'
        self.__m_form_id = None
        self.__m_head_rob_fields_list = None
        self.__m_form_table = None
        self.__m_bill_table_name: str = ''
        self.f_position = None
        self.__m_head_spacer_height = None
        self.__m_head_columns = None
        self.__m_group_manage = 0
        self.__m_link_tree = 0
        self.__m_has_tree = 0
        self.__m_tree_sql = ''
        self.__m_form_sql = None
        self.__m_link_field = ''
        self.__m_form_table_name = None
        self.__m_menus_actions = None
        self.__m_description = None
        self.__m_save_type = None
        self.__m_class = None
        self.__m_rob_flag = None
        self.__interface_add_type = None
        self.__m_rob_qty_name = None
        self.__m_number = None
        self.form_model = None
        self.ms_dict = None


    # region 基本功能
    def create_factory(self, ms_dict: Optional[Dict] = None, parent: Optional[QWidget] = None):

        self.ms_dict = ms_dict
        if self.ms_dict:
            self.__interface_add_type = 'other'  # 单据增加类型，interface 由界面增加， other 其它方式增加
            self.__m_rob_flag = 0  # 红蓝字单据标志：0-蓝字(默认)，1-红字
            self.__m_rob_qty_name = 'FQty'  # 表体数量字段名，默认FQty
            self.__m_head_rob_fields_list = []

            # 主从表配置相关属性
            self.__m_number: str = self.ms_dict['ms_number']  # 主从表编号
            self.__m_class: str = self.ms_dict['ms_class']  # 表单类型('11'-有form表体，'10'-只有form)
            self.__m_save_type: int = self.ms_dict['ms_save_type']  # 保存类型(-1-新增，1-维护旧记录)

            self.__m_description: str = ''
            self.__m_menus_actions: str = ''
            self.__m_form_table_name: str = ''

            # 表结构信息
            self.__m_form_sql: str = ''

            # 界面显示配置 表单的列数、行间隔
            self.__m_head_columns: int = 0
            self.__m_head_spacer_height: int = 0

            # 初始化 t_tableForm、
            self.init_data(ms_dict)

            # 计算可见字段位置
            self.f_position = [idx for idx, visible in enumerate(self.__f_visible_list) if visible == 1]

            # 转到由工厂类 AloneBillFactory创立
            # self.create_form_model()


    def create_form_model(
            self,
            sql: Optional[str] = None
    ) -> None:
        """
        创建form数据模型

        根据提供的SQL查询、记录ID和ID字段名初始化form数据模型。
        如果参数未提供，则使用类中存储的默认值。

        Args:
            sql: 用于查询form数据的SQL语句，如果为None则使用self._head_sql
            fid: form记录ID，默认为-1表示新记录
            fid_name: formID字段名，如果为None则使用self._head_id_name

        Returns:
            None: 方法直接修改实例的head_model属性
        """
        self.form_model = EditableSqlModel(sql=sql)


    def init_data(self, msDict: dict) -> None:
        """
        初始化主从表配置数据

        参数:
            msDict: 主从表配置字典

        功能:
            1. 从数据库加载主表配置信息
            2. 初始化form和表体字段的各种属性列表
            3. 设置界面显示相关的配置参数
        """
        # 从数据库加载主表配置信息
        sql = f"select * from t_tableForm where FNumber = '{self.__m_number}'"
        model = get_model(sql)

        # 基础配置信息
        self.__m_description = model.record(0).value('FDescription')  # 描述信息
        self.__m_menus_actions = model.record(0).value('FMenusAndActions')  # 菜单和动作控制
        self.__m_form_table = model.record(0).value('FFormTable')  # 单据数据表名
        self.__m_form_table_name = model.record(0).value('FFormTableName')  # 单据表名


        # 表结构信息
        self.__m_group_manage = model.record(0).value('FGroupManage')  # groupManage
        self.__m_link_tree = model.record(0).value('FLinkTree')  # hasTree
        self.__m_has_tree = model.record(0).value('FHasTree')  # hasTree
        self.__m_tree_sql = model.record(0).value('FTreeSql')  # treeSQL

        self.__m_form_sql = model.record(0).value('FFormSql')  # formSQL
        self.__m_link_field = model.record(0).value('FLinkField')  # linkField

        self.__m_form_id = model.record(0).value('Fid')  # 主从表配置ID

        # 界面显示配置
        self.__m_head_columns = model.record(0).value('FHeadColumns')  # form网格页头列数
        self.__m_head_spacer_height = model.record(0).value('FHeadSpacerHeight')  # form网格页头间隔

        # 初始化t_masterFormChild，字段对应的列表
        self.__init_form_field_lists()

        # 获取t_masterFormChild表信息
        self.__get_form_table_info()

    def __init_form_field_lists(self) -> None:
        """初始化form字段的各种属性列表"""
        self.__f_id_list = []
        self.__f_xh_list: list = []  # form字段 key
        self.__f_field_list = []  # form字段 字段名
        self.__f_field_name_list = []  # form字段中文名
        self.__f_domain_list = []  # formdomain
        self.__f_label_name_list = []  # form 标签
        self.__f_key_list: list = []  # form字段 key
        self.__f_data_type_list = []  # form字段数据类型
        self.__f_edit_list = []  # form字段是否可编辑
        self.__f_visible_list = []  # form字段是否可见
        self.__f_must_input_list = []  # form字段是否必录
        self.__f_default_value_list = []  # form字段缺省值
        self.__f_widget_list = []  # form字段控件类型
        self.__f_top_foot_list = []  # form字段头部或脚部
        self.__f_row_list = []  # form字段行号
        self.__f_column_list = []  # form字段列号
        self.__f_row_span_list = []  # form字段跨行数
        self.__f_column_span_list = []  # form字段跨列数
        self.__f_relation_table_list = []  # form字段关联表名及sql
        self.__f_relation_table_description_list = []  # form字段关联表界面描述
        self.__f_relation_hide_column_list = []  # form字段关联表界面隐藏列
        self.__f_relation_fields_list = []  # form字段关联表F7面板字段(用于动态拼sql)
        self.__f_relation_field_name_list = []  # form字段关联表中文字段
        self.__f_f7_list = []  # form字段是否F7帮助
        self.__f_relation_get_ret_list = []  # form字段关联表F7面板字段及返回值
        self.__f_f7dict_name_list = []  # form f7字典名
        self.__f_column_width_list = []  # form 表格的列宽
        self.__f_reg_exp_list = []  # form正则表达式
        self.__f_place_holder_text_list = []  # form字段提示文字
        self.__f_align_ment_list = []  # form字段提示文字
        self.__f_decimal_list = []  # form字段小数点位数
        self.__f_range_list = []  # form字段标签名称
        self.__f_validator_list = []  # form字段校验器
        self.__f_group_list = []  # form是否为组
        self.__f_join_sql_list = []  # form是否参数sql
        self.__f_is_query_field_list = []  # form是否参数sql

    def __get_form_table_info(self):
        # 获取form表体相关数据
        # 处理form
        if self.__m_form_id is None:
            self.__m_form_id = -1
        sql = f"select * from t_tableFormChild where FEntityId={self.__m_form_id} order by Fxh"

        model = get_model(sql)
        rows = model.rowCount()

        for i in range(0, rows):
            self.__f_id_list.append(model.record(i).value('FId'))
            self.__f_xh_list.append(model.record(i).value('FXh'))
            self.__f_field_list.append(model.record(i).value('FField').lower())
            self.__f_field_name_list.append(model.record(i).value('FFieldName'))
            self.__f_domain_list.append(model.record(i).value('FDomain'))
            self.__f_label_name_list.append(model.record(i).value('FLabelName'))
            self.__f_key_list.append(model.record(i).value('FKey'))
            self.__f_data_type_list.append(model.record(i).value('FDataType'))
            self.__f_edit_list.append(model.record(i).value('FIsEdit'))
            self.__f_visible_list.append(model.record(i).value('FVisible'))
            self.__f_must_input_list.append(model.record(i).value('FMustInput'))
            self.__f_default_value_list.append(model.record(i).value('FDefaultVal'))
            self.__f_widget_list.append(model.record(i).value('FWidget'))
            self.__f_top_foot_list.append(model.record(i).value('FTopOrFoot'))
            self.__f_row_list.append(model.record(i).value('FRow'))
            self.__f_column_list.append(model.record(i).value('FColumn'))
            self.__f_row_span_list.append(model.record(i).value('FRowSpan'))
            self.__f_column_span_list.append(model.record(i).value('FColumnSpan'))
            self.__f_relation_table_list.append(model.record(i).value('FRelationTable'))
            self.__f_relation_table_description_list.append(model.record(i).value('FRTableDescription'))
            self.__f_relation_hide_column_list.append(model.record(i).value('FRelationHideColumn'))
            self.__f_relation_fields_list.append(model.record(i).value('FRelationFields'))
            self.__f_relation_field_name_list.append(model.record(i).value('FRelationFieldName'))
            self.__f_f7_list.append(model.record(i).value('FIsF7'))
            self.__f_relation_get_ret_list.append(model.record(i).value('FRelationGetAndRet'))
            self.__f_f7dict_name_list.append(model.record(i).value('FF7DictName'))
            self.__f_column_width_list.append(model.record(i).value('FColumnWidth'))
            self.__f_reg_exp_list.append(model.record(i).value('FRegExp'))
            self.__f_place_holder_text_list.append(model.record(i).value('FPlaceHolderText'))
            self.__f_align_ment_list.append(model.record(i).value('FAlignMent'))
            self.__f_decimal_list.append(model.record(i).value('FDecimal'))
            self.__f_range_list.append(model.record(i).value('FRange'))
            self.__f_validator_list.append(model.record(i).value('FValidator'))
            self.__f_group_list.append(model.record(i).value('FGroup'))
            self.__f_join_sql_list.append(model.record(i).value('FJoinSql'))
            self.__f_is_query_field_list.append(model.record(i).value('FIsQueryField'))


    # endregion


    # region 处理domain
    def get_domain_list(self, domain_name: str) -> Optional[Union[List[str], List[Dict[str, str]]]]:
        """

        :param domain_name:
        :return:
        """
        xu_n = domain_dict.get_or_add(domain_name, lambda key: self._dispatch_domain(key))
        if domain_name[0: 3] != 'str':
            result_list = [item['fname'] for item in xu_n]
        else:
            result_list = xu_n
        return result_list

    def _dispatch_domain(self, domain_name: str) -> List[Any]:
        head_str = domain_name[0: 3]
        if head_str == 'str':
            ret_list = self._get_domain_from_str(domain_name)
        elif head_str == 'sql':
            ret_list = self._get_domain_from_sql(domain_name)
        else:
            return []

        return ret_list

    @staticmethod
    def _get_domain_from_str(domain_name: str) -> List[str]:
        """
        从t_domain中取出字符串，并解析
        :param domain_name:
        :return:
        """
        sql = f"select * from t_domain where FName='{domain_name}'"
        model = get_model(sql)
        content = model.record(0).value('FContent')
        content = content.strip()
        return content.split(',')

    @staticmethod
    def _get_domain_from_sql(domain_name: str) -> Union[List[str], List[Dict[str,str]]]:
        """
        从t_domain中取出sql字符串，执行
        :param domain_name:
        :return:
        """
        sql = f"select * from t_domain where FName='{domain_name}'"
        model = get_model(sql)
        sql = model.record(0).value('FContent')
        # 转换为字典列表
        TTD = TableToListDict(sql)
        list_dict = TTD.get_list_dict()

        return list_dict

    # region

    # region  t_masterForm表 属性和方法
    @property
    def m_class(self) -> str:
        """
        单据形式
        :return: 单据形式代码，11=form表体，10=form，01=表体
        :rtype: str
        """
        return self.__m_class

    @m_class.setter
    def m_class(self, value: str) -> None:
        """
        设置单据形式
        :param value: 单据形式代码，11=form表体，10=form，01=表体
        :type value: str
        """
        self.__m_class = value

    @property
    def m_number(self) -> str:
        """
        主表t_masterForm的编码
        :rtype: str
        """
        return self.__m_number

    @m_number.setter
    def m_number(self, val: str) -> None:
        """
        主从表t_masterForm的编码
        :param val: 要设置的单据类型值，-1=新单据，1=旧单据
        :type val: int
        :raises ValueError: 如果输入值不是-1或1时抛出异常
        """
        self.__m_number = val

    @property
    def m_save_type(self) -> int:
        """
        单据保存类型
        :return: -1=新单据，1=旧单据
        :rtype: int
        """
        return self.__m_save_type

    @m_save_type.setter
    def m_save_type(self, val: int) -> None:
        """
        设置单据保存类型
        :param val: -1=新单据，1=旧单据
        :type val: int
        :raises ValueError: 如果值不是-1或1时抛出
        """
        if val not in (-1, 1):
            raise ValueError("单据保存类型必须是-1(新单据)或1(旧单据)")
        self.__m_save_type = val

    @property
    def m_rob_flag(self) -> int:
        """
        获取红蓝字标识
        :return: 红蓝字标识代码
        :rtype: int
        """
        return self.__m_rob_flag

    @m_rob_flag.setter
    def m_rob_flag(self, val: int) -> None:
        """
        设置红蓝字标识
        :param val: 红蓝字标识代码
        :type val: int
        """
        self.__m_rob_flag = val

    @property
    def m_rob_qty_name(self) -> str:
        """
        获取红蓝字单据表体涉及数量的字段名
        """
        return self.__m_rob_qty_name

    @m_rob_qty_name.setter
    def m_rob_qty_name(self, val: str) -> None:
        """
        设置红蓝字单据表体涉及数量的字段名
        :param val: 要设置的字段名称（通常是字符串类型）
        :type val: str
        :raises TypeError: 如果输入不是字符串类型时抛出
        """
        if not isinstance(val, str):
            raise TypeError("字段名必须是字符串类型")
        self.__m_rob_qty_name = val

    @property
    def interface_add_type(self) -> str:
        """
        单据增加类型
        :return: interface 由界面增加， other 其它方式增加
        """
        return self.__interface_add_type

    @interface_add_type.setter
    def interface_add_type(self, val):
        """
        单据增加类型
        :return: interface 由界面增加， other 其它增加方式
        """
        self.__interface_add_type = val

    @property
    def m_form_sql(self) -> str:
        """
        获取formSQL（来自t_masterForm表的FFormSql字段）

        返回:
            str: 主form数据的SQL
        """
        return self.__m_form_sql

    @property
    def m_group_manage(self) -> Optional[int]:
        """
        获取主表hasTree字段值（来自t_masterForm表的FHasTree字段）

        该SQL用于在主从表关系中获取主表的头部信息数据

        返回:
            str:
        """
        return self.__m_group_manage

    @property
    def m_link_tree(self) -> Optional[int]:
        """
        获取主表hasTree字段值（来自t_masterForm表的FHasTree字段）

        该SQL用于在主从表关系中获取主表的头部信息数据

        返回:
            str:
        """
        return self.__m_link_tree

    @property
    def m_has_tree(self) -> Optional[int]:
        """
        获取主表hasTree字段值（来自t_masterForm表的FHasTree字段）

        该SQL用于在主从表关系中获取主表的头部信息数据

        返回:
            str:
        """
        return self.__m_has_tree

    @property
    def m_tree_sql(self) -> Optional[str]:
        """
        获取t_masterForm表的FTreeSql字段）的值

        返回:
            str:
        """
        return self.__m_tree_sql

    @property
    def m_link_field(self) -> Optional[str]:
        """
        获取t_masterForm表的FTreeSql字段）的值

        返回:
            str:
        """
        return self.__m_link_field

    @property
    def m_form_table(self) -> str:
        """
        获取主form表名称
        """
        return self.__m_form_table


    @property
    def m_description(self) -> str:
        """
        获取主从表配置描述信息（来自t_masterForm表的FDescription字段）

        该字段提供关于此主从表配置的说明性文本，用于帮助理解配置用途

        返回:
            str: 配置的详细描述信息
        """
        return self.__m_description

    @property
    def m_menus_actions(self) -> str:
        """
        获取菜单和工具栏动作配置（来自t_masterForm表的FMenusAndActions字段）

        该字段配置TAB页切换时需要保留的菜单项和工具栏命令，
        格式示例：
        {'browseAction':'关闭,过滤', 'editAction':'退回', 'browseMenu':'', 'editMenu':''}

        返回:
            Dict[str, str]: 包含菜单和动作配置的字典，键为动作类型，值为逗号分隔的动作名称列表
        """
        return self.__m_menus_actions

    @property
    def m_form_table_name(self) -> str:
        """
        获取表的中文名称
        """
        return self.__m_form_table_name

    @property
    def m_head_rob_fields_list(self) -> List[str]:
        """
        获取form红蓝字字段（来自t_masterForm表的FHeadRobFields字段）

        返回:
            List[int]: 需要隐藏的form列索引列表（整数列表）
        """
        return self.__m_head_rob_fields_list

    @property
    def m_head_columns(self) -> int:
        """
        得到页头的列数
        :return:
        """
        return self.__m_head_columns

    @property
    def m_head_spacer_height(self) -> int:
        """
        得到页头的间隔高度
        :return:
        """
        return self.__m_head_spacer_height


    # endregion


    # region form属性和方法
    # 以下是form表体共用的字段信息  **********************************
    @property
    def f_id(self) -> int:
        """
        formid
        :return:
        """
        return self.__f_id

    @f_id.setter
    def f_id(self, var: int) -> None:
        """
        设置formid
        :param var:
        :return:
        """
        self.__f_id = int(var)

    @property
    def f_xh_list(self) -> List[int]:
        """
        fxh
        :return:
        """
        return self.__f_xh_list

    @property
    def f_field_list(self) -> List[str]:
        """
        获取form字段英文名称列表

        该列表包含form各字段的英文名称/数据库字段名，用于程序内部处理和数据库操作

        示例: ['id', 'name', 'create_time']

        返回:
            List[str]: form字段英文名称列表
        """
        return self.__f_field_list

    @property
    def f_field_name_list(self) -> List[str]:
        """
        获取form中文字段显示名称列表

        该列表包含form各字段在界面显示的中文名称，与英文字段名一一对应

        示例: ['ID', '姓名', '创建时间']

        返回:
            List[str]: form字段中文字段名列表
        """
        return self.__f_field_name_list

    @property
    def f_domain_list(self) -> List[str]:
        """
        获取form字段domain字段
        返回:
            List[str]: form字段domain列表
        """
        return self.__f_domain_list

    @property
    def f_label_name_list(self) -> List[str]:
        """
        获取form字段标签名称列表

        该列表包含form各字段对应的标签显示名称，用于界面展示
        与字段列表一一对应

        示例: ['ID', '姓名', '创建日期']

        返回:
            List[str]: form字段标签名称列表
        """
        return self.__f_label_name_list


    @property
    def f_key_list(self) -> List[str]:
        """
        获取form字段键名列表

        该列表包含form字段对应的键名/字段名，用于数据绑定和访问

        返回:
            List[str]: form字段键名字符串列表
        """
        return self.__f_key_list

    @property
    def f_data_type_list(self) -> List[str]:
        """
        获取form字段数据类型列表

        该列表定义form各字段的数据类型，可用于数据验证和格式处理
        可能是类型字符串(如'str','int')或Python类型对象(如str, int)

        示例1: ['str', 'int', 'datetime']
        示例2: [str, int, datetime.datetime]

        返回:
            List[Union[str, Type]]: 字段数据类型列表
        """
        return self.__f_data_type_list

    @property
    def f_edit_list(self) -> List[int]:
        """
        获取form各字段的可编辑状态列表

        该列表定义form各字段是否允许用户编辑
        True表示可编辑，False表示只读

        示例: [True, False, True] 表示第2个字段为只读

        返回:
            List[bool]: form字段可编辑状态布尔值列表
        """
        return self.__f_edit_list

    @property
    def f_visible_list(self) -> List[bool]:
        """
        获取form字段可见性配置列表

        该列表定义form各字段是否在界面显示，与字段列表一一对应
        True表示可见，False表示隐藏

        示例: [True, False, True] 表示第2个字段隐藏

        返回:
            List[bool]: form字段可见性布尔值列表
        """
        return self.__f_visible_list

    @property
    def f_must_input_list(self) -> List[int]:
        """
        获取form各字段的必填项配置列表

        该列表定义form各字段是否必须输入
        True表示必填，False表示可选

        示例: [True, False, True] 表示第1和第3个字段必须填写

        返回:
            List[bool]: form字段必填状态布尔值列表
        """
        return self.__f_must_input_list

    @property
    def f_default_value_list(self) -> List[Any]:
        """
        获取form各字段的默认值列表

        该列表包含form各字段的初始默认值，类型应与字段数据类型匹配
        支持多种类型：字符串、数字、日期等

        示例: ['', 0, None] 表示第1字段默认为空字符串，第2字段默认为0

        返回:
            List[Any]: form字段默认值列表
        """
        return self.__f_default_value_list

    @property
    def f_widget_list(self) -> List[str]:
        """
        获取form字段对应控件名称或对象列表

        该列表包含form各字段使用的UI控件类型名称(如'QLineEdit')或控件对象

        示例1: ['QLineEdit', 'QComboBox', 'QDateEdit']
        示例2: [QLineEdit对象, QComboBox对象, None]

        返回:
            List[Union[str, Any]]: 控件类型名称或对象列表
        """
        return self.__f_widget_list

    @property
    def f_top_foot_list(self) -> List[int]:
        """
        得到控件放置页头或页脚的属性
        :return:
        """
        return self.__f_top_foot_list

    @property
    def f_row_list(self) -> List[int]:
        """
        获取form各字段所在的行号列表

        该列表定义form各字段在表格布局中的行位置（从0开始计数）
        用于支持多行form布局的情况

        示例: [0, 0, 1] 表示前两个字段在第1行，第3个字段在第2行

        返回:
            List[int]: form字段对应的行号列表
        """
        return self.__f_row_list

    @property
    def f_column_list(self) -> List[int]:
        """
        获取form各字段所在的列索引列表

        该列表定义form各字段在表格布局中的列位置（从0开始计数）
        与行号列表配合使用确定字段在form网格中的位置

        示例: [0, 1, 0] 表示字段布局为：
               [字段1][字段2]
               [字段3]

        返回:
            List[int]: form字段对应的列索引列表
        """
        return self.__f_column_list

    @property
    def f_row_span_list(self) -> List[int]:
        """
        获取form各字段的行跨度配置列表

        该列表定义form字段在垂直方向占据的行数（默认为1）
        用于实现字段的垂直合并效果

        示例: [1, 2, 1] 表示第2个字段垂直占据2行

        返回:
            List[int]: form字段的行跨度数值列表
        """
        return self.__f_row_span_list

    @property
    def f_column_span_list(self) -> List[int]:
        """
        获取form各字段的列跨度配置列表

        该列表定义form字段在水平方向占据的列数（默认为1）
        用于实现字段的水平合并效果

        示例: [1, 2, 1] 表示第2个字段水平占据2列

        返回:
            List[int]: form字段的列跨度数值列表
        """
        return self.__f_column_span_list

    @property
    def f_relation_table_list(self) -> List[str]:
        """
        f7form字段--关联表名及sql
        :return:
        """
        return self.__f_relation_table_list

    @property
    def f_relation_table_description_list(self) -> List[str]:
        """
        f7form字段--关联表界面描述
        :return:
        """
        return self.__f_relation_table_description_list

    @property
    def f_relation_hide_column_lis(self) -> List[str]:
        """
        f7form字段--关联表界面隐藏列
        :return:
        """
        return self.__f_relation_hide_column_list

    @property
    def f_relation_fields_list(self) -> List[str]:
        """
        f7form字段--关联表F7面板字段(用于动态拼sql)
        :return:
        """
        return self.__f_relation_fields_list

    @property
    def f_relation_field_name_list(self) -> List[str]:
        """
        f7form字段--f7取数及返回字段
        :return:
        """
        return self.__f_relation_field_name_list

    @property
    def f_f7_list(self) -> List[int]:
        """
        是否为f7字段
        :return:
        """
        return self.__f_f7_list

    @property
    def f_relation_get_ret_list(self) -> List[str]:
        """
        f7form字段--关联表中文字段
        :return:
        """
        return self.__f_relation_get_ret_list

    @property
    def f_f7dict_name_list(self) -> List[str]:
        """
        f7form f7字典
        :return:
        """
        return self.__f_f7dict_name_list

    @property
    def f_column_width_list(self) -> List[str]:
        """
        f7form 表格列宽
        :return:
        """
        return self.__f_column_width_list

    @property
    def f_reg_exp_list(self) -> List[str]:
        """
        f7form 表格列宽
        :return:
        """
        return self.__f_reg_exp_list


    @property
    def f_place_holder_text_list(self) -> List[int]:
        """
        获取提示字符
        :return:
        """
        return self.__f_place_holder_text_list


    @property
    def f_align_ment_list(self) -> List[str]:
        """
        f7form 对齐方式
        :return:
        """
        return self.__f_align_ment_list

    @property
    def f_decimal_list(self) -> List[str]:
        """
        f7form 小数位数
        :return:
        """
        return self.__f_decimal_list

    @property
    def f_range_list(self) -> List[str]:
        """
        f7form  数值范围
        :return:
        """
        return self.__f_range_list

    @property
    def f_validator_list(self) -> List[str]:
        """
        f7form  校验器
        :return:
        """
        return self.__f_validator_list


    @property
    def f_group_list(self) -> List[str]:
        """
        f7form  是否为组
        :return:
        """
        return self.__f_group_list


    @property
    def f_join_sql_list(self) -> List[int]:
        """
        获取form字段是否加入SQL语句管理的配置列表

        该列表定义form各字段是否应包含在自动生成的SQL语句中
        True表示包含，False表示排除

        示例: [True, False, True] 表示第2个字段不参与SQL生成

        返回:
            List[bool]: form字段SQL包含状态布尔值列表
        """
        return self.__f_join_sql_list


    @property
    def f_is_query_field_list(self) -> List[int]:
        """
        获取form字段是否加入SQL语句管理的配置列表

        该列表定义form各字段是否应包含在自动生成的SQL语句中
        True表示包含，False表示排除

        示例: [True, False, True] 表示第2个字段不参与SQL生成

        返回:
            List[bool]: form字段SQL包含状态布尔值列表
        """
        return self.__f_is_query_field_list


    @property
    def f_default_val_list(self) -> List[int]:
        """
        获取form字段是否加入SQL语句管理的配置列表

        该列表定义form各字段是否应包含在自动生成的SQL语句中
        True表示包含，False表示排除

        示例: [True, False, True] 表示第2个字段不参与SQL生成

        返回:
            List[bool]: form字段SQL包含状态布尔值列表
        """
        return self.__f_default_value_list


    @property
    def f_align_list(self) -> List[int]:
        """
        获取form字段是否加入SQL语句管理的配置列表

        该列表定义form各字段是否应包含在自动生成的SQL语句中
        True表示包含，False表示排除

        示例: [True, False, True] 表示第2个字段不参与SQL生成

        返回:
            List[bool]: form字段SQL包含状态布尔值列表
        """
        return self.__f_align_ment_list

    # endregion


    # region 其它get方法
    def get_filter_dict(self) -> Dict[str, Any]:
        """
        获取查询界面需要的字段信息
        :return:
        """
        q_dict = {}
        for is_query, field, field_name, field_type in zip(self.f_is_query_field_list,
                                                           self.f_field_list,
                                                           self.f_field_name_list,
                                                           self.f_data_type_list):
            if is_query:
                q_dict[field] = (field_name, field_type,)

        return q_dict

    def get_f_field_column(self, field_name: str) -> int:
        """
        获取表头字段在 h_field_list 中的索引位置。

        :param field_name: 要查找的字段名（不区分大小写）。
        :return: 字段在列表中的索引，如果不存在则返回 -1。
        """
        try:
            return self.f_field_list.index(field_name.lower())
        except ValueError:
            return -1

    def get_f_field_info(self, num: int) -> Dict[str, Any]:
        """
        获取form字段完整配置信息

        参数:
            num (int): 字段索引位置（从0开始）

        返回:
            Dict[str, Any]: 包含字段所有配置的字典，结构为：
            {
                'key': 字段键名,
                'field': 字段英文名,
                'dtype': 数据类型,
                'widget': 控件类型,
                'isedit': 是否可编辑,
                'align': 对齐方式,
                'width': 列宽度,
                'validator': 验证器,
                'column': 列位置,
                'decimal': 小数位数,
                'placeHoderText': 占位文本,
                'isF7': F7帮助配置,
                'relationTable': 关联表,
                'relationFieldName': 关联字段,
                'rTableDescription': 关联表描述,
                'relationHideColumn': 关联隐藏列,
                'relationGetAndRet': 关联获取返回配置,
                'relationFields': 关联字段列表
            }

        异常:
            IndexError: 当num超出范围时抛出
        """
        if num < 0 or num >= len(self.__f_field_list):
            raise IndexError("Field index out of range")

        return {
            'key': self.__f_key_list[num],
            'field': self.__f_field_list[num],
            'domain': self.__f_domain_list[num],
            'dtype': self.__f_data_type_list[num],
            'widget': self.__f_widget_list[num],
            'isedit': self.__f_edit_list[num],
            'align': self.__f_align_ment_list[num],
            'width': self.__f_column_width_list[num],
            'validator': self.__f_validator_list[num],
            'dictName': self.f_f7dict_name_list[num],
            'decimal': self.__f_decimal_list[num],
            'placeHolderText': self.__f_place_holder_text_list[num],
            'isF7': self.__f_f7_list[num],
            'relationTable': self.__f_relation_table_list[num],
            'relationFieldName': self.__f_relation_field_name_list[num],
            'rTableDescription': self.__f_relation_table_description_list[num],
            'relationHideColumn': self.__f_relation_hide_column_list[num],
            'relationGetAndRet': self.__f_relation_get_ret_list[num],
            'relationFields': self.__f_relation_fields_list[num]
        }

    def get_f_column_by_field_name(self, field_Name: str) -> int:
        """
        根据字段名称获取对应的列索引

        参数:
            field_Name (str): 要查找的字段名称（不区分大小写）

        返回:
            int: 字段对应的列索引（从0开始），未找到返回-1

        示例:
            1 >>> get_f_column_by_field_name('fid')
            2  # 返回字段所在的列号
        """
        ret = -1
        field_Name = field_Name.lower()
        for i, field in enumerate(self.__f_field_list):
            if field_Name.lower() == field.lower():
                ret = i
                break
        return ret

    # endregion
